L’objectif de ce tutoriel est de vous aider à comprendre le fonctionnement des listes imbriquées en Python. Vous apprendrez à créer, parcourir et manipuler ces structures pour organiser vos données de manière efficace. À travers des exemples pratiques, vous serez en mesure d’appliquer cette notion dans vos propres projets de programmation.
Les listes imbriquées (ou listes de listes) sont une structure de données fondamentale en Python qui permet de stocker des collections de données organisées hiérarchiquement. Elles sont particulièrement utiles pour représenter des données multidimensionnelles.
Une liste imbriquée est simplement une liste qui contient d'autres listes comme éléments. Cela permet de créer des structures de données à deux dimensions ou plus, similaires à des matrices ou des tableaux.
# Exemple basique d'une liste imbriquée # Représentation des régions du Maroc et leurs villes principales regions_maroc = [ ["Casablanca-Settat", "Casablanca", "Settat", "Mohammédia"], ["Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"], ["Marrakech-Safi", "Marrakech", "Safi", "El Kelaa des Sraghna"] ] # Liste imbriquée avec différents types de données informations_ville = [ ["Marrakech", 928850, "Tourisme", True], ["Tanger", 947952, "Portuaire", True], ["Fès", 1112072, "Artisanat", False] ] # Liste à trois niveaux d'imbrication universites_maroc = [ [ ["Université Mohammed V", "Rabat", ["Droit", "Médecine", "Sciences"]], ["Université Hassan II", "Casablanca", ["Ingénierie", "Économie", "Lettres"]] ], [ ["Université Cadi Ayyad", "Marrakech", ["Sciences", "Technologie"]], ["Université Ibn Tofail", "Kénitra", ["Droit", "Sciences Humaines"]] ] ] print("Liste des régions:", regions_maroc) print("Type de regions_maroc:", type(regions_maroc)) print("Type du premier élément:", type(regions_maroc[0]))
Les listes imbriquées offrent plusieurs avantages pour organiser et manipuler des données complexes de manière structurée :
# AVANTAGE 1: Représentation de données tabulaires # Tableau des températures moyennes par ville au Maroc temperatures_maroc = [ ["Ville", "Janvier", "Juillet", "Annuelle"], ["Casablanca", 12.5, 23.5, 18.5], ["Marrakech", 12.0, 29.0, 20.5], ["Fès", 10.0, 27.0, 18.0], ["Agadir", 14.0, 22.0, 18.0] ] # AVANTAGE 2: Structure hiérarchique naturelle # Organisation administrative du Maroc administration_marocaine = [ ["Région de l'Oriental", ["Préfecture d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"]], ["Province de Jerada", ["Jerada", "Touissit", "Gafait"]] ], ["Région de Souss-Massa", ["Préfecture d'Agadir Ida-Outanane", ["Agadir", "Aït Melloul"]], ["Province de Taroudant", ["Taroudant", "Oulad Berhil", "Aoulouz"]] ] ] # AVANTAGE 3: Flexibilité dans le stockage de données hétérogènes # Informations sur les monuments historiques marocains monuments_maroc = [ ["Koutoubia", "Marrakech", 1158, ["Architecture almohade", "Minaret"], True], ["Hassan II", "Casablanca", 1993, ["Architecture moderne", "Plus haute mosquée"], True], ["Chellah", "Rabat", 1339, ["Site archéologique", "Nécropole"], False] ] # AVANTAGE 4: Facilité de manipulation avec des boucles # Calcul de la température moyenne annuelle par ville print("Températures annuelles par ville:") for i in range(1, len(temperatures_maroc)): ville = temperatures_maroc[i][0] temp_annuelle = temperatures_maroc[i][3] print(f"- {ville}: {temp_annuelle}°C") # AVANTAGE 5: Représentation de matrices pour les calculs mathématiques # Matrice de distances entre villes marocaines (en km) distances_villes = [ [0, 240, 580, 320], # De Casablanca [240, 0, 470, 530], # De Rabat [580, 470, 0, 330], # De Fès [320, 530, 330, 0] # De Marrakech ] villes = ["Casablanca", "Rabat", "Fès", "Marrakech"] print(f"\nDistance de Casablanca à Marrakech: {distances_villes[0][3]} km")
Les listes imbriquées en Python possèdent des particularités importantes à comprendre pour une utilisation efficace :
# CARACTÉRISTIQUE 1: Hétérogénéité des éléments # Une liste imbriquée peut contenir différents types de données donnees_heterogenes = [ ["Maroc", 37, 710850, ["Arabe", "Amazigh"], {"Monnaie": "Dirham"}], ["Espagne", 17, 505990, ["Espagnol"], {"Monnaie": "Euro"}] ] # CARACTÉRISTIQUE 2: Mutabilité # Les listes imbriquées sont modifiables produits_marocains = [ ["Argan", 150.0, "Cosmétique"], ["Safran", 25.0, "Épice"], ["Couscous", 30.0, "Alimentaire"] ] # Modification d'un élément dans une sous-liste produits_marocains[0][1] = 180.0 # Augmentation du prix de l'argan produits_marocains.append(["Zellige", 200.0, "Artisanat"]) # Ajout d'un produit # CARACTÉRISTIQUE 3: Attention aux références # Création problématique avec la multiplication liste_problematique = [[0]] * 3 # Crée 3 références à la même sous-liste liste_problematique[0][0] = 5 # Modifie les 3 sous-listes! print("Liste problématique:", liste_problematique) # [[5], [5], [5]] # Solution: utiliser une compréhension de liste liste_correcte = [[0] for _ in range(3)] liste_correcte[0][0] = 5 print("Liste correcte:", liste_correcte) # [[5], [0], [0]] # CARACTÉRISTIQUE 4: Dimensions variables # Les sous-listes peuvent avoir des tailles différentes festivals_maroc = [ ["Festival des Roses", "Kelaa M'Gouna", "Mai"], ["Festival des Cerises", "Sefrou"], # Mois manquant ["Mawazine", "Rabat", "Mai", "Musique", 2001] # Plus d'infos ] print("\nProduits marocains mis à jour:") for produit in produits_marocains: print(f"- {produit[0]}: {produit[1]} DH ({produit[2]})")
La création de listes imbriquées en Python peut se faire de plusieurs manières, chacune adaptée à des besoins spécifiques. Voyons les différentes méthodes pour définir et initialiser ces structures de données.
Une liste imbriquée est essentiellement une liste contenant d'autres listes comme éléments. Plusieurs approches permettent de les créer selon le contexte d'utilisation.
# MÉTHODE 1: Définition directe avec des crochets # Liste des régions du Maroc avec leurs villes principales regions_direct = [ ["Casablanca-Settat", "Casablanca", "Mohammédia", "Settat"], ["Rabat-Salé-Kénitra", "Rabat", "Salé", "Kénitra"], ["Marrakech-Safi", "Marrakech", "Safi", "El Kelaa des Sraghna"] ] # MÉTHODE 2: Construction progressive avec append() regions_progressive = [] regions_progressive.append(["Tanger-Tétouan-Al Hoceïma", "Tanger", "Tétouan", "Al Hoceïma"]) regions_progressive.append(["Fès-Meknès", "Fès", "Meknès", "Ifrane"]) regions_progressive.append(["Beni Mellal-Khénifra", "Beni Mellal", "Khénifra", "Khouribga"]) # MÉTHODE 3: Utilisation de la multiplication (ATTENTION au piège!) # Méthode problématique - crée des références à la même liste matrice_problematique = [[0] * 3] * 4 # 4 lignes, 3 colonnes matrice_problematique[0][0] = 1 # Modifie toutes les lignes! # MÉTHODE 4: Compréhension de liste (RECOMMANDÉE) matrice_correcte = [[0 for _ in range(3)] for _ in range(4)] matrice_correcte[0][0] = 1 # Modifie seulement la première ligne # MÉTHODE 5: À partir de données existantes villes_maroc = ["Casablanca", "Rabat", "Marrakech", "Fès", "Tanger"] populations = [3350000, 577000, 928000, 1112000, 948000] villes_avec_population = [[ville, pop] for ville, pop in zip(villes_maroc, populations)] print("Définition directe:", regions_direct[0]) print("Construction progressive:", regions_progressive[1]) print("Problème multiplication:", matrice_problematique) print("Solution compréhension:", matrice_correcte) print("À partir de données:", villes_avec_population)
Voici plusieurs exemples concrets montrant comment utiliser les listes imbriquées dans différents contextes avec des données marocaines.
# EXEMPLE 1: Représentation de données tabulaires # Tableau des spécialités culinaires par ville specialites_culinaires = [ ["Ville", "Spécialité", "Saison", "Prix moyen (DH)"], ["Fès", "Pastilla", "Toute l'année", 80], ["Marrakech", "Tanjia", "Hiver", 60], ["Agadir", "Poisson grillé", "Été", 45], ["Casablanca", "Seafood", "Toute l'année", 120] ] # EXEMPLE 2: Structure hiérarchique - Régions et provinces administration_maroc = [ ["Région de l'Oriental", ["Province d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"]], ["Province de Jerada", ["Jerada", "Touissit", "Gafait"]], ["Province de Berkane", ["Berkane", "Ahfir", "Saïdia"]] ], ["Région de Drâa-Tafilalet", ["Province d'Errachidia", ["Errachidia", "Goulmima", "Tinejdad"]], ["Province de Zagora", ["Zagora", "Agdz", "Tamegroute"]] ] ] # EXEMPLE 3: Matrice pour calculs mathématiques # Distances entre villes marocaines (en km) distances = [ [0, 240, 580, 320, 330], # Casablanca [240, 0, 470, 530, 250], # Rabat [580, 470, 0, 330, 650], # Fès [320, 530, 330, 0, 550], # Marrakech [330, 250, 650, 550, 0] # Tanger ] # EXEMPLE 4: Données hétérogènes - Informations touristiques sites_touristiques = [ ["Jemaa el-Fna", "Marrakech", "Place publique", 1000, True, ["Spectacle", "Gastronomie", "Artisanat"]], ["Hassan II", "Casablanca", "Mosquée", 1993, True, ["Architecture", "Religieux"]], ["Volubilis", "Meknès", "Site archéologique", -300, False, ["Histoire", "Romaine"]] ] # EXEMPLE 5: Liste d'étudiants avec notes etudiants_notes = [ ["Amina Alami", "Université Cadi Ayyad", [15.5, 18.0, 16.5]], ["Youssef Benani", "Université Hassan II", [14.0, 17.5, 19.0]], ["Fatima Zahra", "Université Ibn Tofail", [16.0, 15.5, 18.5]] ] # Affichage des exemples print("=== SPÉCIALITÉS CULINAIRES ===") for i in range(1, len(specialites_culinaires)): ligne = specialites_culinaires[i] print(f"- {ligne[0]}: {ligne[1]} ({ligne[3]} DH)") print("\n=== DISTANCES ENTRE VILLES ===") villes = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"] print(f"De Casablanca à Marrakech: {distances[0][3]} km") print(f"De Rabat à Tanger: {distances[1][4]} km") print("\n=== NOTES DES ÉTUDIANTS ===") for etudiant in etudiants_notes: moyenne = sum(etudiant[2]) / len(etudiant[2]) print(f"- {etudiant[0]}: moyenne = {moyenne:.2f}")
Pour des cas plus complexes, Python offre des méthodes avancées pour créer et initialiser des listes imbriquées de manière efficace.
# MÉTHODE 1: Initialisation avec des valeurs par défaut complexes # Création d'un calendrier d'événements marocains def creer_calendrier_mensuel(mois, annee=2024): # Crée une liste de 4 semaines avec 7 jours chacune return [[{"jour": 0, "evenements": []} for _ in range(7)] for _ in range(4)] calendrier_janvier = creer_calendrier_mensuel("Janvier") # MÉTHODE 2: À partir de fichiers ou données externes (simulation) def charger_donnees_regions(): # Simulation de données chargées depuis une source externe donnees_brutes = [ "Casablanca-Settat:Casablanca,Mohammédia,Settat,Benslimane", "Rabat-Salé-Kénitra:Rabat,Salé,Kénitra,Skhirat", "Marrakech-Safi:Marrakech,Safi,El Kelaa,Essaouira" ] regions = [] for ligne in donnees_brutes: nom_region, villes = ligne.split(":") liste_villes = villes.split(",") regions.append([nom_region] + liste_villes) return regions regions_chargees = charger_donnees_regions() # MÉTHODE 3: Transformation de structures de données # Conversion d'un dictionnaire en liste imbriquée universites_dict = { "Université Mohammed V": ["Rabat", 1957, ["Droit", "Médecine"]], "Université Cadi Ayyad": ["Marrakech", 1978, ["Sciences", "Lettres"]], "Université Ibn Tofail": ["Kénitra", 1989, ["Droit", "Sciences"]] } # Conversion en liste imbriquée universites_liste = [[nom] + details for nom, details in universites_dict.items()] # MÉTHODE 4: Génération avec conditions # Liste des villes avec population supérieure à 500,000 habitants villes_maroc = [ ["Casablanca", 3350000], ["Fès", 1112000], ["Tanger", 948000], ["Marrakech", 928000], ["Salé", 890000], ["Meknès", 520000], ["Rabat", 577000] ] grandes_villes = [ville for ville in villes_maroc if ville[1] > 500000] # Affichage des résultats print("Calendrier créé:", len(calendrier_janvier), "semaines") print("Régions chargées:", [r[0] for r in regions_chargees]) print("Universités converties:", len(universites_liste)) print("Grandes villes:", [ville[0] for ville in grandes_villes])
L'accès aux éléments dans les listes imbriquées nécessite une compréhension de la navigation à travers plusieurs niveaux d'indices. Cette section explique comment manipuler efficacement ces structures complexes.
L'accès aux éléments se fait en chaînant les indices entre crochets. Chaque paire de crochets permet de descendre d'un niveau dans la hiérarchie de la liste.
# Structure de données : Régions du Maroc avec leurs villes et monuments donnees_maroc = [ ["Casablanca-Settat", ["Casablanca", ["Mosquée Hassan II", "Corniche", "Place Mohammed V"]], ["Mohammédia", ["Plage des Sablettes", "Port"]] ], ["Marrakech-Safi", ["Marrakech", ["Jemaa el-Fna", "Jardin Majorelle", "Koutoubia"]], ["Safi", ["Médina", "Cité Portugaise"]] ] ] # ACCÈS DE BASE - Premier niveau premiere_region = donnees_maroc[0] deuxieme_region = donnees_maroc[1] print("Première région:", premiere_region[0]) # "Casablanca-Settat" print("Deuxième région:", deuxieme_region[0]) # "Marrakech-Safi" # ACCÈS DEUXIÈME NIVEAU - Villes d'une région villes_casablanca_settat = donnees_maroc[0][1:] # Toutes les villes de la première région premiere_ville = donnees_maroc[0][1] # Première ville de la première région nom_premiere_ville = donnees_maroc[0][1][0] # Nom de la première ville print("\nVilles de Casablanca-Settat:", [ville[0] for ville in villes_casablanca_settat]) print("Première ville:", nom_premiere_ville) # ACCÈS TROISIÈME NIVEAU - Monuments d'une ville monuments_casablanca = donnees_maroc[0][1][1] # Monuments de Casablanca premier_monument = donnees_maroc[0][1][1][0] # Premier monument de Casablanca print("\nMonuments de Casablanca:", monuments_casablanca) print("Premier monument:", premier_monument) # ACCÈS AVEC INDICES NÉGATIFS derniere_region = donnees_maroc[-1] # Dernière région derniere_ville_derniere_region = donnees_maroc[-1][-1] # Dernière ville de la dernière région dernier_monument = donnees_maroc[-1][-1][1][-1] # Dernier monument de la dernière ville print("\nAvec indices négatifs:") print("Dernière région:", derniere_region[0]) print("Dernière ville:", derniere_ville_derniere_region[0]) print("Dernier monument:", dernier_monument) # ACCÈS AVEC SLICING premieres_deux_villes = donnees_maroc[0][1:3] # Premières deux villes de la première région deux_premiers_monuments = donnees_maroc[0][1][1][:2] # Deux premiers monuments de Casablanca print("\nAvec slicing:") print("Deux premières villes:", [ville[0] for ville in premieres_deux_villes]) print("Deux premiers monuments:", deux_premiers_monuments)
Voici des exemples concrets montrant comment accéder et manipuler des données complexes dans des listes imbriquées avec des structures marocaines.
# EXEMPLE 1: Système éducatif marocain systeme_educatif = [ ["Université Mohammed V", "Rabat", ["Faculté des Sciences", ["Mathématiques", "Physique", "Chimie"]], ["Faculté de Médecine", ["Médecine Générale", "Chirurgie", "Pédiatrie"]] ], ["Université Cadi Ayyad", "Marrakech", ["Faculté des Sciences Semlalia", ["Informatique", "Géologie"]], ["Faculté des Lettres", ["Arabe", "Français", "Histoire"]] ] ] # Accès aux différentes informations universite_rabat = systeme_educatif[0] facultes_marrakech = systeme_educatif[1][2:] filieres_medecine = systeme_educatif[0][2][1][1] premiere_filiere_info = systeme_educatif[1][2][1][0] print("=== SYSTÈME ÉDUCATIF MAROCAIN ===") print(f"Université de Rabat: {universite_rabat[0]}") print(f"Facultés à Marrakech: {[fac[0] for fac in facultes_marrakech]}") print(f"Filières de médecine: {filieres_medecine}") print(f"Première filière info: {premiere_filiere_info}") # EXEMPLE 2: Réseau de transport reseau_transport = [ ["ONCF", "Train", ["Ligne Tanger-Casablanca", ["Tanger", "Kénitra", "Rabat", "Casablanca"], 330, 2.5], ["Ligne Fès-Marrakech", ["Fès", "Meknès", "Casablanca", "Marrakech"], 580, 4.0] ], ["CTM", "Bus", ["Rabat-Agadir", ["Rabat", "Casablanca", "Marrakech", "Agadir"], 530, 6.5], ["Fès-Tanger", ["Fès", "Oujda", "Tanger"], 450, 5.0] ] ] # Extraction d'informations spécifiques premiere_ligne_train = reseau_transport[0][2][0] villes_tanger_casablanca = reseau_transport[0][2][0][1] distance_fes_marrakech = reseau_transport[0][2][1][2] duree_rabat_agadir = reseau_transport[1][2][0][3] print("\n=== RÉSEAU DE TRANSPORT ===") print(f"Première ligne train: {premiere_ligne_train}") print(f"Villes Tanger-Casablanca: {villes_tanger_casablanca}") print(f"Distance Fès-Marrakech: {distance_fes_marrakech} km") print(f"Durée Rabat-Agadir: {duree_rabat_agadir} heures") # EXEMPLE 3: Données touristiques complexes tourisme_maroc = [ ["Circuit Impérial", 7, ["Rabat", "Fès", "Meknès", "Marrakech"], [["Hôtel Tour Hassan", 4, 1200], ["Riad Fès", 5, 1800]] ], ["Circuit Désert", 5, ["Marrakech", "Ouarzazate", "Zagora", "Merzouga"], [["Kasbah Aït Benhaddou", 3, 800], ["Campement Désert", 4, 1500]] ] ] # Accès aux données touristiques nom_circuit_imperial = tourisme_maroc[0][0] villes_circuit_desert = tourisme_maroc[1][2] premier_hotel = tourisme_maroc[0][3][0][0] prix_campement = tourisme_maroc[1][3][1][2] duree_circuit = tourisme_maroc[0][1] print("\n=== TOURISME AU MAROC ===") print(f"Circuit: {nom_circuit_imperial} ({duree_circuit} jours)") print(f"Villes du circuit désert: {villes_circuit_desert}") print(f"Premier hôtel: {premier_hotel}") print(f"Prix campement: {prix_campement} DH/nuit")
Pour des structures complexes, il est utile de combiner différentes techniques d'accès et de créer des fonctions utilitaires.
# Structure complexe : Administration territoriale administration_complexe = [ ["Région de l'Oriental", 1.5, # Population en millions [ ["Province d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"], 550000], ["Province de Berkane", ["Berkane", "Ahfir", "Saïdia"], 350000] ] ], ["Région de Souss-Massa", 2.7, [ ["Préfecture d'Agadir Ida-Outanane", ["Agadir", "Aït Melloul"], 600000], ["Province de Taroudant", ["Taroudant", "Oulad Berhil"], 800000] ] ] ] # FONCTION UTILITAIRE : Accès sécurisé avec gestion d'erreurs def acces_securise(liste_imbriquee, *indices): """Accède à un élément de manière sécurisée avec gestion des IndexError""" element = liste_imbriquee try: for index in indices: element = element[index] return element except (IndexError, TypeError): return None # FONCTION : Extraire toutes les villes d'une région def extraire_villes_region(administration, nom_region): """Extrait toutes les villes d'une région donnée""" for region in administration: if region[0] == nom_region: villes = [] for province in region[2]: villes.extend(province[1]) return villes return [] # FONCTION : Calculer la population totale d'une région def population_totale_region(administration, nom_region): """Calcule la population totale d'une région""" for region in administration: if region[0] == nom_region: population_totale = 0 for province in region[2]: population_totale += province[2] return population_totale return 0 # UTILISATION DES FONCTIONS print("=== TECHNIQUES AVANCÉES ===") # Accès sécurisé premiere_province = acces_securise(administration_complexe, 0, 2, 0) ville_inexistante = acces_securise(administration_complexe, 0, 2, 5, 10) # Indices invalides print(f"Première province de l'Oriental: {premiere_province[0]}") print(f"Accès à élément inexistant: {ville_inexistante}") # Extraction de données villes_oriental = extraire_villes_region(administration_complexe, "Région de l'Oriental") population_souss = population_totale_region(administration_complexe, "Région de Souss-Massa") print(f"\nVilles de l'Oriental: {villes_oriental}") print(f"Population de Souss-Massa: {population_souss:,} habitants") # ACCÈS AVEC DÉBALLAGE for region in administration_complexe: nom_region, population_region, provinces = region print(f"\n{nom_region}:") for province in provinces: nom_province, villes, population = province print(f" - {nom_province}: {population:,} habitants")
Le parcours des listes imbriquées est essentiel pour traiter et analyser des données complexes. Python offre plusieurs approches, des boucles imbriquées classiques aux compréhensions de liste plus élégantes.
Les boucles imbriquées sont la méthode la plus intuitive pour parcourir des listes imbriquées. Elles permettent un contrôle précis sur chaque niveau d'imbrication.
# Structure : Régions du Maroc avec villes et monuments regions_maroc = [ ["Casablanca-Settat", ["Casablanca", ["Mosquée Hassan II", "Corniche", "Place Mohammed V"]], ["Mohammédia", ["Plage des Sablettes", "Port"]] ], ["Marrakech-Safi", ["Marrakech", ["Jemaa el-Fna", "Jardin Majorelle", "Koutoubia"]], ["Safi", ["Médina", "Cité Portugaise"]] ], ["Rabat-Salé-Kénitra", ["Rabat", ["Tour Hassan", "Kasbah des Oudayas", "Chellah"]], ["Salé", ["Médina", "Grande Mosquée"]] ] ] # PARCOURS COMPLET - 3 niveaux d'imbrication print("=== PARCOURS COMPLÈT DES RÉGIONS ===") for region in regions_maroc: nom_region = region[0] print(f"\n?️ Région: {nom_region}") # Parcours des villes (niveau 2) for ville_info in region[1:]: nom_ville = ville_info[0] monuments = ville_info[1] print(f" ?️ Ville: {nom_ville}") # Parcours des monuments (niveau 3) for monument in monuments: print(f" ? Monument: {monument}") # PARCOURS AVEC DÉCOMPTAGE print("\n" + "="*50) print("=== STATISTIQUES PAR RÉGION ===") for i, region in enumerate(regions_maroc, 1): nom_region = region[0] nb_villes = len(region) - 1 # -1 pour le nom de région total_monuments = 0 for ville_info in region[1:]: total_monuments += len(ville_info[1]) print(f"{i}. {nom_region}: {nb_villes} villes, {total_monuments} monuments") # PARCOURS AVEC FILTRES print("\n" + "="*50) print("=== VILLES AVEC PLUS DE 2 MONUMENTS ===") for region in regions_maroc: nom_region = region[0] for ville_info in region[1:]: nom_ville = ville_info[0] monuments = ville_info[1] if len(monuments) > 2: print(f"? {nom_ville} ({nom_region}): {len(monuments)} monuments") for monument in monuments: print(f" - {monument}") # EXEMPLE PRATIQUE : Système universitaire universites = [ ["Université Mohammed V", "Rabat", ["Faculté des Sciences", ["Mathématiques", "Physique", "Chimie"]], ["Faculté de Médecine", ["Médecine Générale", "Chirurgie"]] ], ["Université Cadi Ayyad", "Marrakech", ["Faculté des Sciences Semlalia", ["Informatique", "Géologie"]], ["Faculté des Lettres", ["Arabe", "Français"]] ] ] print("\n" + "="*50) print("=== SYSTÈME UNIVERSITAIRE MAROCAIN ===") for universite in universites: nom_univ, ville, facultes = universite print(f"\n? {nom_univ} - {ville}") for faculte in facultes: nom_fac, filieres = faculte print(f" ? {nom_fac}:") for filiere in filieres: print(f" • {filiere}")
Les compréhensions de liste offrent une syntaxe concise et efficace pour parcourir et transformer des listes imbriquées en une seule ligne de code.
# Données : Produits artisanaux marocains par région artisanat_maroc = [ ["Fès", ["Zellige", "Brodery", "Cuir"], [150, 200, 300]], ["Marrakech", ["Tapis", "Poterie", "Lanterne"], [500, 80, 120]], ["Essaouira", ["Marqueterie", "Argan"], [250, 180]], ["Tétouan", ["Céramique", "Textile"], [90, 150]] ] # COMPRÉHENSION SIMPLE : Extraire tous les noms de villes villes_artisanales = [ville[0] for ville in artisanat_maroc] print("Villes artisanales:", villes_artisanales) # COMPRÉHENSION IMBRIQUÉE : Tous les produits artisanaux tous_produits = [produit for ville in artisanat_maroc for produit in ville[1]] print("Tous les produits:", tous_produits) # COMPRÉHENSION AVEC CONDITION : Villes avec plus de 2 produits villes_riches = [ville[0] for ville in artisanat_maroc if len(ville[1]) > 2] print("Villes avec +2 produits:", villes_riches) # COMPRÉHENSION COMPLEXE : Produits avec leurs prix produits_avec_prix = [(ville[0], produit, prix) for ville in artisanat_maroc for produit, prix in zip(ville[1], ville[2])] print("\nProduits avec prix:") for ville, produit, prix in produits_avec_prix: print(f" {ville}: {produit} - {prix} DH") # COMPRÉHENSION POUR CALCULS : Prix moyen par ville prix_moyen_par_ville = [(ville[0], sum(ville[2]) / len(ville[2])) for ville in artisanat_maroc] print("\nPrix moyen par ville:") for ville, prix_moyen in prix_moyen_par_ville: print(f" {ville}: {prix_moyen:.0f} DH") # EXEMPLE AVANCÉ : Système de notation des étudiants etudiants = [ ["Amina Alami", "Université Cadi Ayyad", [15.5, 18.0, 16.5]], ["Youssef Benani", "Université Hassan II", [14.0, 17.5, 19.0]], ["Fatima Zahra", "Université Ibn Tofail", [16.0, 15.5, 18.5]], ["Karim Amrani", "Université Mohammed V", [12.5, 14.0, 13.5]] ] # Moyennes des étudiants avec compréhension moyennes_etudiants = [(etudiant[0], sum(etudiant[2]) / len(etudiant[2])) for etudiant in etudiants] # Étudiants avec mention (moyenne >= 16) etudiants_mention = [nom for nom, moyenne in moyennes_etudiants if moyenne >= 16] # Meilleure note par étudiant meilleures_notes = [(etudiant[0], max(etudiant[2])) for etudiant in etudiants] print("\n" + "="*50) print("=== RÉSULTATS DES ÉTUDIANTS ===") print("\nMoyennes des étudiants:") for nom, moyenne in moyennes_etudiants: print(f" {nom}: {moyenne:.2f}/20") print(f"\nÉtudiants avec mention: {etudiants_mention}") print("\nMeilleures notes:") for nom, meilleure_note in meilleures_notes: print(f" {nom}: {meilleure_note}/20") # COMPRÉHENSION POUR CRÉER UNE NOUVELLE STRUCTURE # Transformation : étudiants avec statut (Admis/Redoublant) etudiants_avec_statut = [ [etudiant[0], etudiant[1], etudiant[2], "Admis" if (sum(etudiant[2]) / len(etudiant[2])) >= 10 else "Redoublant"] for etudiant in etudiants ] print("\nStatut des étudiants:") for etudiant in etudiants_avec_statut: print(f" {etudiant[0]} - {etudiant[3]}")
Pour des structures très complexes, il est utile de combiner différentes techniques et de créer des fonctions récursives ou utilitaires.
# Structure complexe : Organisation administrative marocaine administration_maroc = [ ["Région de l'Oriental", 1.5, # Population en millions [ ["Province d'Oujda-Angad", ["Oujda", "Aïn Sfa", "Bni Khaled"], 550000], ["Province de Berkane", ["Berkane", "Ahfir", "Saïdia"], 350000] ] ], ["Région de Souss-Massa", 2.7, [ ["Préfecture d'Agadir Ida-Outanane", ["Agadir", "Aït Melloul"], 600000], ["Province de Taroudant", ["Taroudant", "Oulad Berhil", "Aoulouz"], 800000] ] ] ] # FONCTION RÉCURSIVE : Aplatir une liste imbriquée def aplanir_liste(liste_imbriquee): """Aplatit récursivement une liste imbriquée""" resultat = [] for element in liste_imbriquee: if isinstance(element, list): resultat.extend(aplanir_liste(element)) else: resultat.append(element) return resultat # FONCTION : Parcours avec traitement conditionnel def parcours_conditionnel(administration, seuil_population=500000): """Parcourt l'administration et filtre par seuil de population""" resultats = [] for region in administration: nom_region, pop_region, provinces = region for province in provinces: nom_province, villes, population = province if population >= seuil_population: resultats.append({ 'region': nom_region, 'province': nom_province, 'population': population, 'villes': villes }) return resultats # FONCTION : Génération de rapports def generer_rapport_administratif(administration): """Génère un rapport complet de l'administration""" rapport = { 'total_regions': len(administration), 'total_provinces': 0, 'total_villes': 0, 'population_totale': 0, 'regions': [] } for region in administration: nom_region, pop_region, provinces = region info_region = { 'nom': nom_region, 'population_region': pop_region, 'nb_provinces': len(provinces), 'provinces': [] } for province in provinces: nom_province, villes, population = province info_province = { 'nom': nom_province, 'population': population, 'nb_villes': len(villes), 'villes': villes } info_region['provinces'].append(info_province) rapport['total_provinces'] += 1 rapport['total_villes'] += len(villes) rapport['population_totale'] += population rapport['regions'].append(info_region) return rapport # UTILISATION DES FONCTIONS AVANCÉES print("=== TECHNIQUES AVANCÉES DE PARCOURS ===") # Aplanissement elements_aplatis = aplanir_liste(administration_maroc) print(f"\nÉléments aplatis ({len(elements_aplatis)} éléments):") print(elements_aplatis[:10]) # Affiche les 10 premiers # Parcours conditionnel provinces_peuplees = parcours_conditionnel(administration_maroc, 500000) print(f"\nProvinces avec +500,000 habitants:") for province in provinces_peuplees: print(f" {province['province']} ({province['region']}): {province['population']:,} hab.") # Rapport administratif rapport = generer_rapport_administratif(administration_maroc) print(f"\n? RAPPORT ADMINISTRATIF:") print(f"Régions: {rapport['total_regions']}") print(f"Provinces: {rapport['total_provinces']}") print(f"Villes: {rapport['total_villes']}") print(f"Population totale: {rapport['population_totale']:,} habitants") # PARCOURS AVEC ITERTOOLS import itertools # Toutes les combinaisons de régions et provinces combinaisons = list(itertools.chain.from_iterable( [[(region[0], province[0]) for province in region[2]] for region in administration_maroc] )) print(f"\nCombinaisons régions-provinces ({len(combinaisons)}):") for region, province in combinaisons: print(f" {region} → {province}")
La manipulation des listes imbriquées nécessite une compréhension précise de la structure hiérarchique. Cette section couvre les opérations essentielles d'ajout, de suppression et de modification d'éléments.
L'ajout et la suppression d'éléments dans des listes imbriquées peuvent se faire à différents niveaux de la hiérarchie, en utilisant les méthodes standards des listes Python.
# Structure initiale : Régions du Maroc avec villes regions_maroc = [ ["Casablanca-Settat", ["Casablanca", ["Mosquée Hassan II", "Corniche"]], ["Mohammédia", ["Plage des Sablettes"]] ], ["Marrakech-Safi", ["Marrakech", ["Jemaa el-Fna", "Jardin Majorelle"]] ] ] print("=== STRUCTURE INITIALE ===") for region in regions_maroc: print(f"{region[0]}: {[ville[0] for ville in region[1:]]}") # AJOUT D'ÉLÉMENTS print("\n" + "="*50) print("=== AJOUT D'ÉLÉMENTS ===") # 1. Ajouter une nouvelle région (niveau 1) nouvelle_region = ["Rabat-Salé-Kénitra", ["Rabat", ["Tour Hassan", "Kasbah des Oudayas"]], ["Salé", ["Médina"]]] regions_maroc.append(nouvelle_region) print("✅ Nouvelle région ajoutée: Rabat-Salé-Kénitra") # 2. Ajouter une ville à une région existante (niveau 2) regions_maroc[0].append(["Settat", ["Médina", "Place Mohammed V"]]) print("✅ Nouvelle ville ajoutée à Casablanca-Settat: Settat") # 3. Ajouter un monument à une ville existante (niveau 3) regions_maroc[1][1][1].append("Koutoubia") print("✅ Nouveau monument ajouté à Marrakech: Koutoubia") # 4. Insertion à une position spécifique regions_maroc[0][1][1].insert(1, "Place Mohammed V") print("✅ Monument inséré à position 1 dans Casablanca") # SUPPRESSION D'ÉLÉMENTS print("\n" + "="*50) print("=== SUPPRESSION D'ÉLÉMENTS ===") # 1. Supprimer le dernier monument d'une ville (niveau 3) dernier_monument = regions_maroc[0][1][1].pop() print(f"✅ Dernier monument supprimé de Casablanca: {dernier_monument}") # 2. Supprimer un monument spécifique par valeur if "Plage des Sablettes" in regions_maroc[0][2][1]: regions_maroc[0][2][1].remove("Plage des Sablettes") print("✅ Monument supprimé de Mohammédia: Plage des Sablettes") # 3. Supprimer une ville par index (niveau 2) ville_supprimee = regions_maroc[0].pop(2) print(f"✅ Ville supprimée de Casablanca-Settat: {ville_supprimee[0]}") # 4. Supprimer une région entière (niveau 1) region_supprimee = regions_maroc.pop(2) print(f"✅ Région supprimée: {region_supprimee[0]}") # 5. Vider tous les monuments d'une ville regions_maroc[0][1][1].clear() print("✅ Tous les monuments de Casablanca supprimés") # AFFICHAGE FINAL print("\n" + "="*50) print("=== STRUCTURE FINALE ===") for i, region in enumerate(regions_maroc, 1): print(f"\n{i}. {region[0]}:") for ville in region[1:]: print(f" - {ville[0]}: {ville[1]}") # EXEMPLE PRATIQUE : Gestion d'inventaire de produits artisanaux inventaire_artisanal = [ ["Fès", ["Zellige", 50, 150.0], ["Brodery", 30, 200.0] ], ["Marrakech", ["Tapis", 20, 500.0], ["Poterie", 40, 80.0] ] ] print("\n" + "="*50) print("=== GESTION D'INVENTAIRE ARTISANAL ===") # Ajouter un nouveau produit à Fès inventaire_artisanal[0].append(["Cuir", 25, 300.0]) print("✅ Nouveau produit ajouté à Fès: Cuir") # Supprimer un produit épuisé for i, produit in enumerate(inventaire_artisanal[1][1:]): if produit[1] == 0: # Quantité épuisée produit_supprime = inventaire_artisanal[1].pop(i+1) print(f"✅ Produit épuisé supprimé: {produit_supprime[0]}") print("\nInventaire final:") for ville in inventaire_artisanal: print(f"\n{ville[0]}:") for produit in ville[1:]: print(f" - {produit[0]}: {produit[1]} unités, {produit[2]} DH")
La modification d'éléments spécifiques dans des listes imbriquées nécessite une navigation précise vers l'élément cible. Plusieurs techniques permettent d'effectuer ces modifications efficacement.
# Structure : Système de réservation hôtelière au Maroc hotels_maroc = [ ["Marrakech", ["La Mamounia", 5, 2500.0, 10], # [nom, étoiles, prix, chambres_disponibles] ["Riad Dar Anika", 4, 800.0, 5] ], ["Fès", ["Riad Fès", 5, 1800.0, 8], ["Palais Faraj", 5, 2200.0, 12] ], ["Casablanca", ["Four Seasons", 5, 3000.0, 15], ["Hyatt Regency", 4, 1200.0, 20] ] ] print("=== SYSTÈME DE RÉSERVATION HÔTELIÈRE ===") print("État initial:") for ville in hotels_maroc: print(f"\n{ville[0]}:") for hotel in ville[1:]: print(f" - {hotel[0]} ({hotel[1]}★): {hotel[2]} DH, {hotel[3]} chambres") # MODIFICATIONS DIRECTES PAR INDICES print("\n" + "="*50) print("=== MODIFICATIONS DIRECTES ===") # 1. Augmenter le prix d'un hôtel spécifique hotels_maroc[0][1][2] = 2800.0 # La Mamounia print("✅ Prix de La Mamounia augmenté à 2800 DH") # 2. Réduire les chambres disponibles après réservation hotels_maroc[1][1][3] -= 2 # Riad Fès print("✅ 2 chambres réservées à Riad Fès") # 3. Changer la classification d'un hôtel hotels_maroc[2][2][1] = 5 # Hyatt Regency devient 5 étoiles print("✅ Hyatt Regency promu 5 étoiles") # MODIFICATIONS AVEC RECHERCHE print("\n" + "="*50) print("=== MODIFICATIONS AVEC RECHERCHE ===") # Fonction pour trouver et modifier un hôtel def modifier_prix_hotel(hotels, nom_hotel, nouveau_prix): """Modifie le prix d'un hôtel spécifique""" for ville in hotels: for hotel in ville[1:]: if hotel[0] == nom_hotel: ancien_prix = hotel[2] hotel[2] = nouveau_prix return True, ancien_prix return False, 0 # Appliquer une promotion sur Palais Faraj succes, ancien_prix = modifier_prix_hotel(hotels_maroc, "Palais Faraj", 1900.0) if succes: print(f"✅ Promotion appliquée à Palais Faraj: {ancien_prix} → 1900 DH") # MODIFICATIONS EN MASSE print("\n" + "="*50) print("=== MODIFICATIONS EN MASSE ===") # Augmenter tous les prix de 10% for ville in hotels_maroc: for hotel in ville[1:]: hotel[2] *= 1.10 # +10% print("✅ Tous les prix augmentés de 10%") # Réinitialiser les chambres disponibles pour les hôtels 5 étoiles for ville in hotels_maroc: for hotel in ville[1:]: if hotel[1] == 5: hotel[3] = 15 # Réinitialiser à 15 chambres print("✅ Chambres réinitialisées pour tous les hôtels 5 étoiles") # AFFICHAGE FINAL print("\n" + "="*50) print("=== ÉTAT FINAL DU SYSTÈME ===") for ville in hotels_maroc: print(f"\n{ville[0]}:") for hotel in ville[1:]: print(f" - {hotel[0]} ({hotel[1]}★): {hotel[2]:.0f} DH, {hotel[3]} chambres") # EXEMPLE AVANCÉ : Gestion des notes d'étudiants etudiants_notes = [ ["Amina Alami", "Université Cadi Ayyad", [["Mathématiques", 15.5], ["Physique", 18.0], ["Chimie", 16.5]] ], ["Youssef Benani", "Université Hassan II", [["Mathématiques", 14.0], ["Physique", 17.5], ["Informatique", 19.0]] ] ] print("\n" + "="*50) print("=== GESTION DES NOTES D'ÉTUDIANTS ===") # Corriger une note spécifique for etudiant in etudiants_notes: if etudiant[0] == "Amina Alami": for note in etudiant[2]: if note[0] == "Mathématiques": note[1] = 16.0 # Correction print(f"✅ Note de Mathématiques corrigée pour Amina Alami: 16.0/20") # Ajouter des points bonus pour tous les étudiants for etudiant in etudiants_notes: for note in etudiant[2]: note[1] = min(20, note[1] + 0.5) # Bonus de 0.5 point print("✅ 0.5 point bonus ajouté à toutes les notes") print("\nNotes finales:") for etudiant in etudiants_notes: print(f"\n{etudiant[0]} ({etudiant[1]}):") for note in etudiant[2]: print(f" - {note[0]}: {note[1]}/20")
Pour des opérations complexes, il est utile de créer des fonctions spécialisées qui encapsulent la logique de manipulation des listes imbriquées.
# Structure : Réseau de transport marocain reseau_transport = [ ["ONCF", "Train", ["Tanger-Casablanca", ["Tanger", "Kénitra", "Rabat", "Casablanca"], 330, 2.5], ["Fès-Marrakech", ["Fès", "Meknès", "Casablanca", "Marrakech"], 580, 4.0] ], ["CTM", "Bus", ["Rabat-Agadir", ["Rabat", "Casablanca", "Marrakech", "Agadir"], 530, 6.5], ["Fès-Tanger", ["Fès", "Oujda", "Tanger"], 450, 5.0] ] ] # FONCTION : Ajouter une nouvelle ligne de transport def ajouter_ligne_transport(reseau, compagnie, type_transport, nom_ligne, villes, distance, duree): """Ajoute une nouvelle ligne de transport au réseau""" for transport in reseau: if transport[0] == compagnie and transport[1] == type_transport: nouvelle_ligne = [nom_ligne, villes, distance, duree] transport.append(nouvelle_ligne) return True # Si la compagnie n'existe pas, la créer nouvelle_compagnie = [compagnie, type_transport, [nom_ligne, villes, distance, duree]] reseau.append(nouvelle_compagnie) return True # FONCTION : Supprimer une ligne par nom def supprimer_ligne_transport(reseau, nom_ligne): """Supprime une ligne de transport par son nom""" for transport in reseau: for i in range(len(transport) - 1, 1, -1): # Parcours inverse if transport[i][0] == nom_ligne: ligne_supprimee = transport.pop(i) return ligne_supprimee return None # FONCTION : Mettre à jour la durée d'un trajet def mettre_a_jour_duree(reseau, nom_ligne, nouvelle_duree): """Met à jour la durée d'une ligne de transport""" for transport in reseau: for ligne in transport[2:]: if ligne[0] == nom_ligne: ancienne_duree = ligne[3] ligne[3] = nouvelle_duree return ancienne_duree return None # UTILISATION DES FONCTIONS AVANCÉES print("=== MANIPULATION AVANCÉE DU RÉSEAU DE TRANSPORT ===") # Ajouter une nouvelle ligne ajouter_ligne_transport(reseau_transport, "ONCF", "Train", "Casablanca-Agadir", ["Casablanca", "Marrakech", "Agadir"], 420, 3.5) print("✅ Nouvelle ligne ajoutée: Casablanca-Agadir") # Ajouter une nouvelle compagnie ajouter_ligne_transport(reseau_transport, "Supratours", "Bus", "Marrakech-Zagora", ["Marrakech", "Ouarzazate", "Zagora"], 350, 5.0) print("✅ Nouvelle compagnie et ligne ajoutées: Supratours") # Supprimer une ligne ligne_supprimee = supprimer_ligne_transport(reseau_transport, "Fès-Tanger") if ligne_supprimee: print(f"✅ Ligne supprimée: {ligne_supprimee[0]}") # Mettre à jour une durée ancienne_duree = mettre_a_jour_duree(reseau_transport, "Rabat-Agadir", 7.0) if ancienne_duree: print(f"✅ Durée mise à jour pour Rabat-Agadir: {ancienne_duree} → 7.0 heures") # AFFICHAGE FINAL print("\n" + "="*50) print("=== RÉSEAU DE TRANSPORT FINAL ===") for transport in reseau_transport: print(f"\n{transport[0]} ({transport[1]}):") for ligne in transport[2:]: print(f" - {ligne[0]}: {ligne[1]} | {ligne[2]}km, {ligne[3]}h")
Les listes imbriquées trouvent leur utilité dans de nombreux scénarios réels. Cette section présente deux cas d'usage fondamentaux : la représentation de matrices pour les calculs mathématiques et le stockage de données complexes comme les systèmes de gestion scolaire.
Les matrices sont parfaitement représentées par des listes imbriquées, où chaque sous-liste correspond à une ligne de la matrice. Cette structure est idéale pour les opérations mathématiques et les traitements de données tabulaires.
# EXEMPLE 1: Matrice de distances entre villes marocaines (en km) distances_villes = [ # Casa Rabat Fès Marrak Tanger Agadir [0, 240, 580, 320, 330, 470], # Casablanca [240, 0, 470, 530, 250, 530], # Rabat [580, 470, 0, 330, 650, 720], # Fès [320, 530, 330, 0, 550, 230], # Marrakech [330, 250, 650, 550, 0, 680], # Tanger [470, 530, 720, 230, 680, 0] # Agadir ] villes = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger", "Agadir"] print("=== MATRICE DE DISTANCES ENTRE VILLES MAROCAINES ===") print("Villes:", villes) print("\nMatrice des distances (km):") for i in range(len(distances_villes)): print(f"{villes[i]:<12}", end="") for j in range(len(distances_villes[i])): print(f"{distances_villes[i][j]:<6}", end="") print() # Opérations sur la matrice print("\n" + "="*50) print("=== OPÉRATIONS SUR LA MATRICE ===") # Distance entre deux villes spécifiques ville_depart = "Casablanca" ville_arrivee = "Marrakech" i = villes.index(ville_depart) j = villes.index(ville_arrivee) distance = distances_villes[i][j] print(f"Distance {ville_depart} → {ville_arrivee}: {distance} km") # Ville la plus proche d'une ville donnée (hors elle-même) ville_reference = "Fès" idx_ref = villes.index(ville_reference) distances_from_ref = distances_villes[idx_ref] # Exclure la distance à elle-même (0) distances_filtrees = [d for d in distances_from_ref if d > 0] plus_proche_distance = min(distances_filtrees) idx_plus_proche = distances_from_ref.index(plus_proche_distance) ville_plus_proche = villes[idx_plus_proche] print(f"Ville la plus proche de {ville_reference}: {ville_plus_proche} ({plus_proche_distance} km)") # EXEMPLE 2: Matrice de production agricole par région (tonnes) production_agricole = [ # Blé Orge Olives Agrumes Dates [120000, 80000, 15000, 50000, 2000], # Chaouia-Ouardigha [80000, 60000, 25000, 30000, 5000], # Marrakech-Safi [50000, 40000, 40000, 15000, 8000], # Fès-Meknès [30000, 20000, 10000, 80000, 12000], # Souss-Massa [15000, 10000, 5000, 20000, 15000] # Drâa-Tafilalet ] regions_agricoles = ["Chaouia-Ouardigha", "Marrakech-Safi", "Fès-Meknès", "Souss-Massa", "Drâa-Tafilalet"] cultures = ["Blé", "Orge", "Olives", "Agrumes", "Dates"] print("\n" + "="*50) print("=== PRODUCTION AGRICOLE PAR RÉGION (tonnes) ===") # Production totale par culture production_totale_culture = [] for j in range(len(cultures)): total = 0 for i in range(len(regions_agricoles)): total += production_agricole[i][j] production_totale_culture.append(total) print("\nProduction totale par culture:") for culture, production in zip(cultures, production_totale_culture): print(f" {culture}: {production:,} tonnes") # Région avec la plus grande production totale production_par_region = [] for i in range(len(regions_agricoles)): total_region = sum(production_agricole[i]) production_par_region.append(total_region) max_production = max(production_par_region) idx_max = production_par_region.index(max_production) region_max = regions_agricoles[idx_max] print(f"\nRégion la plus productive: {region_max} ({max_production:,} tonnes)") # EXEMPLE 3: Matrice d'adjacence pour réseau routier # 1 = connexion directe, 0 = pas de connexion directe reseau_routier = [ # Casa Rabat Fès Marrak Tanger [0, 1, 1, 1, 1], # Casablanca [1, 0, 1, 1, 1], # Rabat [1, 1, 0, 1, 0], # Fès [1, 1, 1, 0, 0], # Marrakech [1, 1, 0, 0, 0] # Tanger ] villes_reseau = ["Casablanca", "Rabat", "Fès", "Marrakech", "Tanger"] print("\n" + "="*50) print("=== RÉSEAU ROUTIER (matrice d'adjacence) ===") # Villes connectées à Casablanca ville_centrale = "Casablanca" idx_centrale = villes_reseau.index(ville_centrale) connexions = reseau_routier[idx_centrale] villes_connectees = [villes_reseau[i] for i in range(len(connexions)) if connexions[i] == 1 and i != idx_centrale] print(f"\nVilles directement connectées à {ville_centrale}: {villes_connectees}") # Degré de connectivité de chaque ville print("\nDegré de connectivité des villes:") for i in range(len(villes_reseau)): degre = sum(reseau_routier[i]) - reseau_routier[i][i] # Exclure la boucle sur soi print(f" {villes_reseau[i]}: {degre} connexion(s)")
Les listes imbriquées excellent dans le stockage de données structurées complexes, comme les systèmes de gestion scolaire où chaque élève possède plusieurs notes et informations personnelles.
# SYSTÈME DE GESTION SCOLAIRE MAROCAIN # Structure : [Nom, Prénom, École, Classe, [Liste des matières avec notes]] eleves_maroc = [ ["Alami", "Amina", "Lycée Mohammed V", "Terminale Sciences", [["Mathématiques", [16.5, 15.0, 17.5]], ["Physique-Chimie", [14.0, 16.5, 15.0]], ["SVT", [18.0, 17.0, 16.5]], ["Philosophie", [13.5, 14.0]]] ], ["Benani", "Youssef", "Lycée Hassan II", "Terminale Sciences", [["Mathématiques", [12.0, 14.5, 13.0]], ["Physique-Chimie", [15.5, 16.0, 14.5]], ["SVT", [11.5, 13.0, 12.5]], ["Philosophie", [16.0, 15.5]]] ], ["Zahra", "Fatima", "Lycée Moulay Youssef", "Terminale Lettres", [["Arabe", [18.5, 17.0, 19.0]], ["Français", [16.0, 15.5, 17.5]], ["Histoire-Géo", [14.5, 16.0, 15.0]], ["Philosophie", [17.0, 18.5]]] ], ["Amrani", "Karim", "Lycée Mohammed V", "Terminale Sciences", [["Mathématiques", [19.0, 18.5, 17.0]], ["Physique-Chimie", [17.5, 16.0, 18.0]], ["SVT", [15.0, 16.5, 14.5]], ["Philosophie", [13.0, 14.5]]] ] ] print("=== SYSTÈME DE GESTION SCOLAIRE MAROCAIN ===") print("Données des élèves:") for eleve in eleves_maroc: nom, prenom, ecole, classe, matieres = eleve print(f"\n? {prenom} {nom}") print(f" École: {ecole}") print(f" Classe: {classe}") print(f" Matières:") for matiere in matieres: nom_matiere, notes = matiere moyenne = sum(notes) / len(notes) print(f" - {nom_matiere}: {notes} (moyenne: {moyenne:.2f}/20)") # CALCULS ET STATISTIQUES print("\n" + "="*50) print("=== STATISTIQUES ET ANALYSES ===") # 1. Moyenne générale par élève print("\n? MOYENNES GÉNÉRALES DES ÉLÈVES:") for eleve in eleves_maroc: nom, prenom, ecole, classe, matieres = eleve toutes_notes = [] for matiere in matieres: toutes_notes.extend(matiere[1]) moyenne_generale = sum(toutes_notes) / len(toutes_notes) mention = "Très Bien" if moyenne_generale >= 16 else \ "Bien" if moyenne_generale >= 14 else \ "Assez Bien" if moyenne_generale >= 12 else "Passable" print(f" {prenom} {nom}: {moyenne_generale:.2f}/20 - {mention}") # 2. Meilleur élève par matière print("\n? MEILLEURS ÉLÈVES PAR MATIÈRE:") # Collecter toutes les matières uniques toutes_matieres = set() for eleve in eleves_maroc: for matiere in eleve[4]: toutes_matieres.add(matiere[0]) for matiere in toutes_matieres: meilleur_eleve = None meilleure_moyenne = 0 for eleve in eleves_maroc: nom, prenom, ecole, classe, matieres_eleve = eleve # Chercher la matière chez cet élève for m in matieres_eleve: if m[0] == matiere: moyenne_matiere = sum(m[1]) / len(m[1]) if moyenne_matiere > meilleure_moyenne: meilleure_moyenne = moyenne_matiere meilleur_eleve = f"{prenom} {nom}" break if meilleur_eleve: print(f" {matiere}: {meilleur_eleve} ({meilleure_moyenne:.2f}/20)") # 3. Performance par école print("\n? PERFORMANCE MOYENNE PAR ÉCOLE:") ecoles = {} for eleve in eleves_maroc: nom, prenom, ecole, classe, matieres = eleve if ecole not in ecoles: ecoles[ecole] = [] # Calculer la moyenne générale de l'élève toutes_notes = [] for matiere in matieres: toutes_notes.extend(matiere[1]) moyenne_eleve = sum(toutes_notes) / len(toutes_notes) ecoles[ecole].append(moyenne_eleve) for ecole, moyennes in ecoles.items(): moyenne_ecole = sum(moyennes) / len(moyennes) print(f" {ecole}: {moyenne_ecole:.2f}/20 ({len(moyennes)} élève(s))") # 4. Ajout d'un nouvel élève print("\n" + "="*50) print("=== AJOUT D'UN NOUVEL ÉLÈVE ===") nouvel_eleve = [ "Bennani", "Mehdi", "Lycée Hassan II", "Terminale Sciences", [["Mathématiques", [14.5, 15.0, 13.5]], ["Physique-Chimie", [16.0, 15.5, 14.0]], ["SVT", [13.0, 14.5, 12.5]], ["Philosophie", [15.5, 14.0]]] ] eleves_maroc.append(nouvel_eleve) print("✅ Nouvel élève ajouté: Mehdi Bennani") # 5. Mise à jour des notes print("\n" + "="*50) print("=== MISE À JOUR DES NOTES ===") # Ajouter une nouvelle note en Mathématiques pour Amina Alami for eleve in eleves_maroc: if eleve[0] == "Alami" and eleve[1] == "Amina": for matiere in eleve[4]: if matiere[0] == "Mathématiques": matiere[1].append(18.0) # Nouvelle note nouvelle_moyenne = sum(matiere[1]) / len(matiere[1]) print(f"✅ Nouvelle note ajoutée pour Amina Alami en Mathématiques: 18.0") print(f" Nouvelle moyenne en Mathématiques: {nouvelle_moyenne:.2f}/20") break break # AFFICHAGE FINAL DU SYSTÈME print("\n" + "="*50) print("=== SYSTÈME COMPLET AVEC {len(eleves_maroc)} ÉLÈVES ===") print(f"Nombre total d'élèves dans le système: {len(eleves_maroc)}") # Compter le nombre total de notes total_notes = 0 for eleve in eleves_maroc: for matiere in eleve[4]: total_notes += len(matiere[1]) print(f"Nombre total de notes enregistrées: {total_notes}") # Élèves par classe classes = {} for eleve in eleves_maroc: classe = eleve[3] if classe not in classes: classes[classe] = 0 classes[classe] += 1 print(f"Répartition par classe: {classes}")
Au-delà des cas d'usage classiques, les listes imbriquées permettent de modéliser des systèmes complexes comme les réseaux sociaux, les inventaires, ou les planifications.
# APPLICATION 1: Réseau social d'étudiants marocains reseau_social = [ ["Amina Alami", "Casablanca", "Informatique", ["Youssef Benani", "Fatima Zahra", "Karim Amrani"], # Amis [["Photo vacances", 156], ["Projet Python", 89]] # Publications [titre, likes] ], ["Youssef Benani", "Rabat", "Médecine", ["Amina Alami", "Mehdi Bennani"], [["Stage hôpital", 234], ["Voyage Tanger", 167]] ], ["Fatima Zahra", "Fès", "Littérature", ["Amina Alami", "Karim Amrani"], [["Poème printemps", 312], ["Exposition art", 198]] ] ] print("=== RÉSEAU SOCIAL ÉTUDIANT MAROCAIN ===") # Statistiques du réseau total_utilisateurs = len(reseau_social) total_publications = 0 total_likes = 0 for utilisateur in reseau_social: total_publications += len(utilisateur[4]) for publication in utilisateur[4]: total_likes += publication[1] print(f"Utilisateurs: {total_utilisateurs}") print(f"Publications: {total_publications}") print(f"Likes totaux: {total_likes}") print(f"Moyenne de likes par publication: {total_likes/total_publications:.1f}") # APPLICATION 2: Inventaire de produits artisanaux inventaire_artisanal = [ ["Fès", [["Zellige", 50, 150.0, "Artisan1"], # [produit, quantité, prix, artisan] ["Brodery", 30, 200.0, "Artisan2"], ["Cuir", 25, 300.0, "Artisan3"]] ], ["Marrakech", [["Tapis", 20, 500.0, "Artisan4"], ["Poterie", 40, 80.0, "Artisan5"], ["Lanterne", 35, 120.0, "Artisan6"]] ], ["Essaouira", [["Marqueterie", 15, 250.0, "Artisan7"], ["Argan", 60, 180.0, "Artisan8"]] ] ] print("\n" + "="*50) print("=== INVENTAIRE ARTISANAL MAROCAIN ===") # Valeur totale de l'inventaire par ville print("\n? VALEUR TOTALE PAR VILLE:") for ville in inventaire_artisanal: nom_ville = ville[0] valeur_totale = 0 for produit in ville[1]: valeur_totale += produit[1] * produit[2] # quantité * prix print(f" {nom_ville}: {valeur_totale:,.0f} DH") # Produit le plus cher par ville print("\n? PRODUIT LE PLUS CHER PAR VILLE:") for ville in inventaire_artisanal: nom_ville = ville[0] produits = ville[1] if produits: produit_plus_cher = max(produits, key=lambda x: x[2]) print(f" {nom_ville}: {produit_plus_cher[0]} - {produit_plus_cher[2]} DH") print(f"\n? Ces exemples démontrent la puissance des listes imbriquées") print(f" pour modéliser des systèmes complexes du monde réel!")
Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.
Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!